// 时间戳格式化yy-MM-dd hh:mm:ss
const formatDateTime = timeStamp => {
    let y, M, d, h, m, s;
    let date = new Date(timeStamp);
    y = date.getFullYear();
    M = date.getMonth() + 1;
    d = date.getDate();
    h = date.getHours();
    m = date.getMinutes();
    s = date.getSeconds();
    M = M < 10 ? "0" + M : M;
    d = d < 10 ? "0" + d : d;
    h = h < 10 ? "0" + h : h;
    m = m < 10 ? "0" + m : m;
    s = s < 10 ? "0" + s : s;
    let dateTime = `${y}-${M}-${d} ${h}:${m}:${s}`;
    return dateTime;
}


// 时间戳格式化yy-MM-dd
const formatDate = timeStamp => {
    let y, M, d, h, m, s;
    let date = new Date(timeStamp);
    y = date.getFullYear();
    M = date.getMonth() + 1;
    d = date.getDate();
    M = M < 10 ? "0" + M : M;
    d = d < 10 ? "0" + d : d;
    let newDate = `${y}-${M}-${d}`;
    return newDate;
}

// 时间戳格式化yy-MM
const formatYearMonth = timeStamp => {
    let y, M;
    let date = new Date(timeStamp);
    y = date.getFullYear();
    M = date.getMonth() + 1;
    M = M < 10 ? "0" + M : M;
    let newDate = `${y}-${M}`;
    return newDate;
}

// 格式标准时间 为yy年mm月
const formatYMDate = time => {
    // 创建日期对象
    var date = new Date(time);

    // 获取年份和月份
    var year = date.getFullYear();
    var month = date.getMonth() + 1; // 月份从0开始，所以需要加1

    // 构建年月格式字符串
    var yearMonthString = year + '年' + (month < 10 ? '0' + month : month) + '月';

    // 返回结果
    return yearMonthString;
}

const formatYMonth = (value)=>{
    // 将数字转换为字符串，以便于截取年份和月份
    let valueStr = value.toString();
    
    // 确保数字长度为6位
    if (valueStr.length !== 6) {
        return value
    }
    
    // 截取前四位为年份，后两位为月份
    let year = valueStr.substring(0, 4);
    let month = valueStr.substring(4, 6);
    
    // 返回格式化后的字符串
    return `${year}年${month}月`;
}
// 格式标准时间 为yy年mm月dd日
const formatYMDDate = time => {
    // 创建日期对象
    var date = new Date(time);

    // 获取年份和月份
    var year = date.getFullYear();
    var month = date.getMonth() + 1; // 月份从0开始，所以需要加1
    var day = date.getDate();


    // 构建年月日格式字符串
    var formattedDate = year + '年' + (month < 10 ? '0' + month : month) + '月' + (day < 10 ? '0' + day : day) + '日';

    // 返回结果
    return formattedDate;

}

// 格式化时间 今天 HH:MM:SS
const addLeadingZero = (number) => {
    return ('0' + number).slice(-2);
}
const formatTime = (inputTime) => {
    const inputDate = new Date(inputTime);
    const now = new Date();

    const inputYear = inputDate.getFullYear();
    const inputMonth = inputDate.getMonth() + 1;
    const inputDay = inputDate.getDate();
    const inputHours = inputDate.getHours();
    const inputMinutes = inputDate.getMinutes();
    const inputSeconds = inputDate.getSeconds();

    const nowYear = now.getFullYear();
    const nowMonth = now.getMonth() + 1;
    const nowDay = now.getDate();

    if (inputYear === nowYear && inputMonth === nowMonth && inputDay === nowDay) {
        return `今天 ${addLeadingZero(inputHours)}:${addLeadingZero(inputMinutes)}:${addLeadingZero(inputSeconds)}`;
    } else if (inputYear === nowYear && inputMonth === nowMonth && inputDay === nowDay - 1) {
        return `昨天 ${addLeadingZero(inputHours)}:${addLeadingZero(inputMinutes)}:${addLeadingZero(inputSeconds)}`;
    } else {
        return `${inputYear}-${addLeadingZero(inputMonth)}-${addLeadingZero(inputDay)} ${addLeadingZero(inputHours)}:${addLeadingZero(inputMinutes)}:${addLeadingZero(inputSeconds)}`;
    }
}


const transformNumber = (amount, type)=>{
    if (type === 'point') {
        // 转换为分级单位，保留小数
        console.log("amount * 100", amount * 100);
        return amount * 100;
    } else if (type === 'whole') {
        // 转换为元单位，保留两位小数
        return (amount / 100).toFixed(2);
    } else {
        // 如果类型不正确，则返回原始金额
        return amount;
    }
}

const splitNumber = (input)=>{  
 // 确保输入是字符串类型  
 let str = String(input);  
 
 if (str === "0.00" || str === "0") {
    return ["0", "00"];
}
      
 // 查找小数点（如果有的话）  
 let decimalIndex = str.indexOf('.');  
   
 // 如果没有小数点，则在字符串末尾添加.00  
 if (decimalIndex === -1) {  
     str += '.00';  
     decimalIndex = str.length - 3; // 指向整数部分的最后一位之后  
 }  
   
 // 提取整数部分和小数部分  
 let integerPart = str.slice(0, decimalIndex);  
 let decimalPart = str.slice(decimalIndex + 1); // 提取所有小数部分  
   
 // 如果小数部分不足两位，则补0  
 decimalPart = decimalPart.padEnd(2, '0');  
   
 // 返回数组  
 return [integerPart, decimalPart];
}  

// 通过List生成tree
const getTree = (list, parentId) => {
    let treeList = []
    treeList = list.filter(item => {
        return item.parentId == parentId
    })
    treeList.forEach(item => {
        item.children = getTree(list, item.id)
    });
    return treeList
}

/**
 * 从 URL 中获取指定参数名对应的参数值
 * @param {string} url URL 字符串
 * @param {string} paramName 要获取的参数名
 * @returns {string|null} 参数值，如果未找到则返回 null
 */
export function getParamFromUrl(url, code) {
    url = url + "";
    let regstr = "/(\\?|\\&)" + code + "=([^\\&]+)/";
    let reg = eval(regstr);
    //eval可以将 regstr字符串转换为 正则表达式
    let result = url.match(reg);
    if (result && result[2]) {
        return result[2];
    }
}

/**
 * 删除URL中指定search参数,会将参数值一起删除
 * @param {string} url 地址字符串
 * @param {array} aParam 要删除的参数key数组，如['name','age']
 * @return {string} 返回新URL字符串
 */
const deUrlParam = (url, params) => {
    for (var index = 0; index < params.length; index++) {
        var item = params[index];
        var fromIndex = url.indexOf(item + "="); //必须加=号，避免参数值中包含item字符串
        if (fromIndex !== -1) {
            // 通过url特殊符号，计算出=号后面的的字符数，用于生成replace正则
            var startIndex = url.indexOf("=", fromIndex);
            var endIndex = url.indexOf("&", fromIndex);
            var hashIndex = url.indexOf("#", fromIndex);

            var reg = "";
            if (endIndex !== -1) {
                // 后面还有search参数的情况
                var num = endIndex - startIndex;
                reg = new RegExp(item + "=.{" + num + "}");
                url = url.replace(reg, "");
            } else if (hashIndex !== -1) {
                // 有hash参数的情况
                var num = hashIndex - startIndex - 1;
                reg = new RegExp("&?" + item + "=.{" + num + "}");
                url = url.replace(reg, "");
            } else {
                // search参数在最后或只有一个参数的情况
                reg = new RegExp("&?" + item + "=.+");
                url = url.replace(reg, "");
            }
        }
    }
    var noSearchParam = url.indexOf("=");
    if (noSearchParam === -1) {
        url = url.replace(/\?/, ""); // 如果已经没有参数，删除？号
    }
    return url;
}

// 去掉URL上所有参数
const extractBaseUrl = (url) => {
    // 使用正则表达式匹配并替换URL中的参数部分（以?开头的部分）
    var baseUrl = url.replace(/\?.*$/, ''); // 替换?及其后面的所有字符为空字符串
    // 使用正则表达式匹配并替换URL中的锚点部分（以#开头的部分）
    baseUrl = baseUrl.replace(/#.*$/, ''); // 替换#及其后面的所有字符为空字符串
    return baseUrl;
}

let stringToArray = (str) => {
    return str ? str.split(/[,，\s]/) : [];
}


export default {
    formatDateTime,
    formatYearMonth,
    formatYMDate,
    formatYMonth,
    formatYMDDate,
    formatDate,
    formatTime,
    transformNumber,
    splitNumber,
    getTree,
    getParamFromUrl,
    deUrlParam,
    extractBaseUrl,
    stringToArray
}
